package utils;

import org.junit.Test;

import java.util.Arrays;

/**
 * @author aodre , QQ : 480029069
 * @date 2023/7/6 9:40
 */
public class Mock_Data {


    /**
     * 提供了一种生成 随机地图(二维矩阵的 思路!)
     */
    public static char[][] genarateRandomMap(int n, int m) {
        char[][] map = new char[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                int r = (int) (Math.random() * 5);
                if (r == 0) {
                    map[i][j] = 'U';
                } else if (r == 1) {
                    map[i][j] = 'D';
                } else if (r == 2) {
                    map[i][j] = 'L';
                } else if (r == 3) {
                    map[i][j] = 'R';
                } else {
                    map[i][j] = '.';
                }
            }
        }
        map[(int) (Math.random() * n)][(int) (Math.random() * m)] = 'O';
        return map;
    }

     /*
     一定 要保证， 这个 所写的 板子的 正确性！
     如果这个 板子，都有问题还，扯 什么后续
     */


    /**
     * 首先生成 随机数组的函数！
     *
     * @param arraySize 数组的大小（根据 题目的 不同， 也可能是 一个数组的  最大长度， 随机生成 数组的 长度 在 1 ~  arraySize 之间）
     * @param max       数组中元素的最大值
     * @param min       一个指标， 如果 min = 0， 代表 数组中的元素，>=0 ，min = 1， 代表 全是正数  min = -1 ，可正 ke 负 ， 可为 0
     * @param fix       如果 fix = true 代表， 数组的长度 固定， 反之， 数组的长度 不固定
     * @return 一个 生成的随机的数组(长度可以随机， 也可以 固定， 看具体题目的要求)
     */
    public static int[] ramdomArray(int arraySize, int max, int min, boolean fix) {
        int ramdomArraySize = fix ? arraySize : (int) (Math.random() * (arraySize + 1)); // 数组的长度 , 由fix 来控制 是否随机
        int arr[] = new int[ramdomArraySize];
        if (min == 0) {
            for (int i = 0; i < ramdomArraySize; i++) {
                arr[i] = (int) (Math.random() * (max + 1)); // arr[i] = [0 , max]
            }
        } else if (min == 1) {
            for (int i = 0; i < ramdomArraySize; i++) {
                arr[i] = (int) (Math.random() * (max)) + 1;//  arr[i] =  [1 , max + 1)
            }
        } else {
            for (int i = 0; i < ramdomArraySize; i++) {
                arr[i] = (int) (Math.random() * (max + 1) - Math.random() * (max + 1)); // 可正 可 负 可为 0
            }
        }
        return arr;
    }

    /*
     这里 可以讲 这个 测试 正确的方法, 直接实现的一个函数式编程的写法:
     比如 在这里面声明一个函数式接口 FunctionInterface, 作为 testRight的一个参数进行
     进行  方法 的对比 这样感觉可行!
     */
    public void testRight() {
        int testTimes = 0; // 自己写！
        int arraySize = 0;
        int max = 0;
        int min = 0;
        boolean fix = true;
        boolean isSuccess = true;
        for (int i = 0; i < testTimes; i++) {
            int[] ints = ramdomArray(arraySize, max, min, fix);
            int arr1[] = Arrays.copyOf(ints, ints.length);
            int arr2[] = Arrays.copyOf(ints, ints.length);
            // 你的方法
            myFunction(arr1);
            absoluteRightFunction(arr2);
            if (!Arrays.equals(arr1, arr2)) {
                 /*
                  说明 有问题， 可以打印下，数组，看下是什么 问题！
                  */
                isSuccess = false;
                System.out.println(Arrays.toString(ints));
            }
        }
        System.out.println(isSuccess ? "success" : "fuck!");
    }

    private void absoluteRightFunction(int[] arr2) {
    }

    private void myFunction(int[] arr1) {
    }

    public boolean isEquals(int arr1[], int arr2[]) {
        /*
         一些 数组 null ， emptu 的边界判断就省略了！
         */
        boolean flag = true;
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                flag = false;
                break;
            }
        }
        return flag;
    }

    @Test
    public void test() {
        for (int i = 0; i < 100; i++) {
            System.out.println((int) (Math.random() * 100) - (int) (Math.random() * 100));
        }

    }





}
